package com.nuo.test.lock;

import java.util.Random;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.locks.Condition;  
import java.util.concurrent.locks.Lock;  
import java.util.concurrent.locks.ReentrantLock;  
  
/** 
 * 单个Condition去控制一个缓冲区，多线程对缓冲区做读写操作，要保证缓冲区满的时侯不会 
 * 被写，空的时候不会被读；单个Condition控制会出错误： 当缓冲区还有一个位置时，多个写线程 
 * 同时访问，则只有一个写线程可以对其进行写操作，操作完之后，唤醒在这个condition上等待的 
 * 其他几个写线程，如果判断用IF语句的话就会出现继续向缓冲区添加。 
 * @author Administrator 
 * 
 */  
public class ConditionError {  
    Lock lock = new ReentrantLock();  
    Condition condition = lock.newCondition();  
    String[] container = new String[10];  
    int index = 0;  
    public static void main(String[] args) {  
        ConditionError conditionError = new ConditionError();  
        conditionError.test();  
    }  
      
    public void test(){  
        ExecutorService threadPool = Executors.newCachedThreadPool();  
        for(int i = 0; i < 14; i++){//先用14个线程去写，则有4个线程会被阻塞  
            threadPool.execute(new Runnable(){  
  
                public void run() {  
                    put();  
                }  
                  
            });  
        }  
          
        Executors.newSingleThreadExecutor().execute(new Runnable(){//用一个线程去取，则会通知4个阻塞的写线程工作，此时  
                                                                //会有一个线程向缓冲区写，写完后去通知在这个condition上等待  
                                                                //的取线程，这是它的本意，但是它唤醒了写线程，因为只有一个condition  
                                                                //不能有选择的唤醒写取线程，此时就需要有多个Condition  
            public void run() {  
                try {  
                    Thread.sleep(10000);  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                get();  
            }  
              
        });  
    }  
      
    /** 
     * 向缓冲去写数据 
     */  
    public void put(){  
        lock.lock();  
        try{  
            System.out.println(Thread.currentThread().getName() + "当前位置:" + index + "-----------------------------");  
            while(index == 10){  
                try {  
                    System.out.println(Thread.currentThread().getName() + "处于阻塞状态！");  
                    condition.await();  
//                  index = 0;  
                } catch (InterruptedException e) {  
                	System.out.println("get");
//                    e.printStackTrace();  
                }  
            }  
            container[index] = new String(new Random().nextInt() + "");  
            condition.signalAll();  
            index ++;  
        } finally {  
            lock.unlock();  
        }  
    }  
      
    /** 
     * 从缓冲区拿数据 
     */  
    public void get(){  
        lock.lock();  
        try{  
            while(index == 0){  
                try {  
                    System.out.println("get--------" + Thread.currentThread().getName() + "处于阻塞");  
                    condition.await();  
                } catch (InterruptedException e) {  
                	System.out.println("get");
//                	e.printStackTrace();  
                }  
            }  
            index --;  
            System.out.println("get---------" + Thread.currentThread().getName() + "唤醒阻塞");  
            condition.signalAll();  
              
              
        } finally {  
              
            lock.unlock();  
        }  
    }  
}  